home *** CD-ROM | disk | FTP | other *** search
/ Clickx 65 / Clickx 65.iso / software / internet / xmarks / xmarks-3.1.1.xpi / chrome / content / foxmarks-bookmark.js < prev    next >
Encoding:
JavaScript  |  2009-05-05  |  9.9 KB  |  283 lines
  1. /*
  2.  Copyright 2007-2008 Foxmarks Inc.
  3.  
  4.  foxmarks-bookmark.js: component that implements the logical interface to
  5.  related to syncing datatypes.
  6.  
  7. For FF2, the heavy lifting is in rdf.js
  8. For FF3, the heavy lifting is in places.js
  9.  */
  10.  
  11.  
  12. function applyCommonBookmarkFunctions(me){
  13.  
  14.     me.DiscontinuityPrompt= function() {
  15.         var sb = Bundle().GetStringFromName;
  16.  
  17.         // get a reference to the prompt service component.
  18.         var ps = Cc["@mozilla.org/embedcomp/prompt-service;1"].
  19.           getService(Ci.nsIPromptService);
  20.  
  21.         var flags = ps.BUTTON_TITLE_IS_STRING * ps.BUTTON_POS_0 +
  22.               ps.BUTTON_TITLE_IS_STRING * ps.BUTTON_POS_1 +
  23.               ps.BUTTON_TITLE_CANCEL    * ps.BUTTON_POS_2;
  24.  
  25.         var rv = ps.confirmEx(null, sb("disc.title"), sb("disc.body"), flags,
  26.             sb("disc.merge"), sb("disc.download"), null, null, {});
  27.  
  28.         return rv;
  29.     };
  30.  
  31.     me.handleNidConflict = function(lnode, snode, conflicts){
  32.         var nodes = { 
  33.             local: lnode,
  34.             server: snode
  35.         };
  36.         var ntype = lnode.ntype;
  37.         var chromeUrl;
  38.  
  39.         if (ntype == "folder") {
  40.             chromeUrl = 
  41.                 "chrome://foxmarks/content/foxmarks-folderconflict.xul";
  42.         // Special case: name-change only for microsummary
  43.         } else if (ntype == "microsummary" && 
  44.                 conflicts.length == 1 && conflicts[0] == "name") {
  45.             return "local";
  46.         } else {
  47.             chromeUrl = 
  48.                 "chrome://foxmarks/content/foxmarks-bookmarkconflict.xul";
  49.         }
  50.         return OpenConflictDialog(chromeUrl, nodes);
  51.     };
  52.     me.ClobberDialog = function(currNum, lastNum) {
  53.  
  54.         // put up Clobber Dialog and return true if user okays
  55.         // sync, otherwise false.
  56.  
  57.         var retval = { okay: false };
  58.  
  59.         var topwin = Cc['@mozilla.org/appshell/window-mediator;1'].
  60.             getService(Ci.nsIWindowMediator).
  61.             getMostRecentWindow(null);
  62.         
  63.         if (!topwin) {
  64.             LogWrite("ClobberDialog: Couldn't find a topwin!");
  65.             return false;
  66.         }
  67.  
  68.  
  69.         var win = topwin.openDialog(
  70.             "chrome://foxmarks/content/foxmarks-clobber.xul", "_blank",
  71.             "chrome,dialog,modal,centerscreen", retval, currNum, lastNum);
  72.  
  73.         LogWrite("ClobberDialog: retval.okay is " + retval.okay);
  74.         
  75.         return retval.okay;
  76.     };
  77.  
  78.     me.getBaselineName = function(){
  79.         return "xmarks-baseline-" + gSettings.hash + "json";
  80.     };
  81.     me.syncType = "bookmarks";
  82.  
  83.     me.merge = function(dest, source) {
  84.         // Merge the given nodeset into us.
  85.         // Walk through our node hiearchy and, in parallel,
  86.         // source's hierarchy. Discard from further consideration any item
  87.         // inside us that loosely matches* anything in the source. For any
  88.         // item that exists in the source but not us, recusrively copy that
  89.         // item into ourselves (being careful to generate new nid's for each
  90.         // copied item).
  91.         //
  92.         // *Loosely matches, in this context, means that the node's ntype,
  93.         // name, and url (if present) match for any two items in the same
  94.         // place in the hiearchy.
  95.  
  96.         var self = this;
  97.         var folders = [[NODE_ROOT, NODE_ROOT]];
  98.         var toolbars = [
  99.             ValidNid(dest, dest.Node(NODE_ROOT, false, true).tnid),
  100.             ValidNid(source, source.Node(NODE_ROOT, false, true).tnid)];
  101.         var unfiledRoots = [
  102.             ValidNid(dest, dest.Node(NODE_ROOT, false, true).unid),
  103.             ValidNid(source, source.Node(NODE_ROOT, false, true).unid)];
  104.         var mergeToolbars = false;
  105.         var mergeUnfiledRoots = false;
  106.        // var ds = new NativeDatasource();
  107.  
  108.         if (toolbars[0] && toolbars[1]) {
  109.             folders.push(toolbars);
  110.             mergeToolbars = true;
  111.         }
  112.  
  113.         if (unfiledRoots[0] && unfiledRoots[1]) {
  114.             folders.push(unfiledRoots);
  115.             mergeUnfiledRoots = true;
  116.         }
  117.  
  118.         while (folders.length) {
  119.             var f = folders.pop();
  120.             var us = dest.Node(f[0]);
  121.             var them = source.Node(f[1]);
  122.             LogWrite(">> Merge processing folder " + us.name + " (" + 
  123.                     us.nid + ")");
  124.             // makin' copies!
  125.             var ourchildren = us.children ? us.children.slice() : [];
  126.             var theirchildren = them.children ? them.children.slice() : [];
  127.  
  128.             for (var i = 0; i < theirchildren.length; ++i) {
  129.                 var theiritem = theirchildren[i];
  130.                 if (mergeToolbars && theiritem == toolbars[1])
  131.                     continue;   // skip it, we've already processed it
  132.                 if (mergeUnfiledRoots && theiritem == unfiledRoots[1])
  133.                     continue;   // Ditto.
  134.                 var matched = FindMatch(theiritem);
  135.                 if (matched >= 0) {
  136.                     if (dest.Node(ourchildren[matched]).ntype == "folder") {
  137.                         folders.push([ourchildren[matched], theirchildren[i]]);
  138.                     }
  139.                     ourchildren.splice(matched, 1);
  140.                 } else {
  141.                     ReplicateNode(source, theirchildren[i], us.nid);
  142.                 }
  143.             }
  144.         }
  145.  
  146.         if (!toolbars[0] && toolbars[1]) {
  147.             dest.Node(NODE_ROOT, true).tnid = toolbars[1];
  148.         }
  149.  
  150.         if (!unfiledRoots[0] && unfiledRoots[1]) {
  151.             dest.Node(NODE_ROOT, true).unid = unfiledRoots[1];
  152.         }
  153.  
  154.         function FindMatch(nid) {
  155.             // nid is an item in source.
  156.             // Try to find an acceptable match in ourchildren.
  157.             if (nid == toolbars[1] || nid == unfiledRoots[1])
  158.                 return -1;  // These special roots are never matched here.
  159.             var them = source.Node(nid);
  160.             var themurl =self.NormalizeUrl(them.ntype == "feed" ? 
  161.                     them.feedurl : them.url);
  162.             var themname = NormalizedName(them);
  163.             for (var i = 0; i < ourchildren.length; ++i) {
  164.                 var child = ourchildren[i];
  165.                 if (child == toolbars[0] || child == unfiledRoots[0])
  166.                     continue;
  167.                 var us = dest.Node(child);
  168.                 var usurl =self.NormalizeUrl(us.ntype == "feed" ? 
  169.                         us.feedurl : us.url);
  170.                 var usname = NormalizedName(us);
  171.                 if (usname == themname && us.ntype == them.ntype
  172.                         && usurl == themurl) {
  173.                     return i;
  174.                 }
  175.             }
  176.             return -1;
  177.         }
  178.  
  179.         function NormalizedName(node) {
  180.             if (node.ntype == "separator") {
  181.                 return "";
  182.             } else if (node.ntype == "microsummary") {
  183.                 return node.generateduri || rtrim(node.name);
  184.             } else {
  185.                 return rtrim(node.name);
  186.             }
  187.         }
  188.         
  189.         function ReplicateNode(source, nid, pnid) {
  190.             // Copy the given node (including children if it's a folder)
  191.             // into us, generating new nids along the way.
  192.  
  193.             LogWrite("Entered ReplicateNode(" + nid + ")");
  194.  
  195.             function ReplicateNodeInternal(nid, pnid) {
  196.                 if (mergeToolbars && nid == toolbars[1])
  197.                     return;
  198.                 var attrs = source.Node(nid).GetSafeAttrs();
  199.                 attrs.pnid = pnid;
  200.                 var newNid =self.GenerateNid();
  201.                 dest.Do_insert(newNid, attrs);
  202.  
  203.                 if (attrs.ntype == 'folder') {
  204.                     var children = source.Node(nid).children;
  205.                     if (children) {
  206.                         for (var i = 0; i < children.length; ++i) {
  207.                             ReplicateNodeInternal(children[i], newNid);
  208.                         }
  209.                     }
  210.                 }
  211.             }
  212.  
  213.             // Fun with closures: note that we create ds just once
  214.             // and keep it in a closure as we recursively process
  215.             // nid and its children. Creating a native datasource
  216.             // *could* be expensive, depending on platform, so this
  217.             // is likely justified.
  218.             ReplicateNodeInternal(nid, pnid);
  219.         }
  220.  
  221.         function rtrim(s) {
  222.             return s ? s.replace(/\s+$/, "") : s;
  223.         }
  224.  
  225.         function ValidNid(ns, nid) {
  226.             return ns.Node(nid, false, true) ? nid : null;
  227.         }
  228.     };
  229.  
  230.  
  231.     me.orderIsImportant = true;
  232.     me.IGNORABLE ={ created: true, visited: true, modified: true, private: true };
  233.     me.NONULLFIELDS = { name: true, description: true, shortcuturl: true };
  234.     
  235.     me.compareNodes = function(snode, onode, attrs){
  236.         var important = [];
  237.  
  238.         // Iterate over other's attrs, add mistmach/missings.
  239.         for (var attr in onode) {
  240.             if (attr == "children" || attr == "pnid" ||
  241.                     !onode.hasOwnProperty(attr))
  242.                 continue;
  243.             if (!equals(snode[attr], onode[attr])) {
  244.                 attrs[attr] = onode[attr];
  245.                
  246.                 if(this.NONULLFIELDS[attr] && !attrs[attr]){
  247.                     attrs[attr] = "";
  248.                     LogWrite("Updating Null field: " + attr);
  249.                 }
  250.  
  251.                 if (!this.IGNORABLE[attr]) {
  252.                     important.push(attr);
  253.                 }
  254.             }
  255.         }
  256.  
  257.         // Iterate over self's attrs, add deletions.
  258.         for (var attr in snode) {
  259.             if (attr == "children" || !snode.hasOwnProperty(attr))
  260.                 continue;
  261.             if (!(attr in onode)) {
  262.                 attrs[attr] = null;
  263.                 if(this.NONULLFIELDS[attr]){
  264.                     attrs[attr] = "";
  265.                     LogWrite("Updating Null field: " + attr);
  266.                 }
  267.                 if (!this.IGNORABLE[attr]) {
  268.                     important.push(attr);
  269.                 }
  270.             }
  271.         }
  272.         
  273.         // Special case: don't generate update on microsummary name
  274.         // change.
  275.         if (snode.ntype == "microsummary" && important.length == 1 &&
  276.                 important[0] == 'name') {
  277.             return false;
  278.         }
  279.  
  280.         return important.length > 0;
  281.     };
  282. }
  283.